1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
 
2
 
 
 
2
 
2
 
 
 
 
 
 
 
1
2
 
 
 
 
 
2
 
 
2
 
 
2
2
 
1
 
 
 
2
 
 
1
1
1
 
1
1
 
 
1
1
 
1
 
 
1
 
2
 
 
 
 
 
1
 
1
 
1
 
 
 
 
1
2
2
3
3
3
3
1
 
 
3
3
 
 
 
 
3
 
 
 
1
3
1
 
 
 
1
1
 
 
 
 
 
 
 
1
 
1
1
1
 
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
1
 
 
 
 
 
 
 
 
 
 
 
1
 
 
6
6
 
1
 
2
 
1
 
2
 
 
 
 
1
1
 
1
 
 
 
 
1
 
 
 
 
 
 
1
 
 
1
1
 
 
1
1
 
1
1
1
1
1
1
1
 
1
1
 
1
 
 
 
 
/*
example.js
 
quickstart example
 
instruction
    1. save this script as example.js
    2. run the shell command:
        $ npm install npmtest-rdb && PORT=8081 node example.js
    3. play with the browser-demo on http://127.0.0.1:8081
*/
 
 
 
/* istanbul instrument in package npmtest_rdb */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - pre-init
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        // init utility2_rollup
        local = local.global.utility2_rollup || (local.modeJs === 'browser'
            ? local.global.utility2_npmtest_rdb
            : global.utility2_moduleExports);
        // export local
        local.global.local = local;
    }());
    switch (local.modeJs) {
 
 
 
    // post-init
    // run browser js-env code - post-init
    /* istanbul ignore next */
    case 'browser':
        local.testRunBrowser = function (event) {
            Eif (!event || (event &&
                    event.currentTarget &&
                    event.currentTarget.className &&
                    event.currentTarget.className.includes &&
                    event.currentTarget.className.includes('onreset'))) {
                // reset output
                Array.from(
                    document.querySelectorAll('body > .resettable')
                ).forEach(function (element) {
                    switch (element.tagName) {
                    case 'INPUT':
                    case 'TEXTAREA':
                        element.value = '';
                        break;
                    default:
                        element.textContent = '';
                    }
                });
            }
            switch (event && event.currentTarget && event.currentTarget.id) {
            case 'testRunButton1':
                // show tests
                Eif (document.querySelector('#testReportDiv1').style.display === 'none') {
                    document.querySelector('#testReportDiv1').style.display = 'block';
                    document.querySelector('#testRunButton1').textContent =
                        'hide internal test';
                    local.modeTest = true;
                    local.testRunDefault(local);
                // hide tests
                } else {
                    document.querySelector('#testReportDiv1').style.display = 'none';
                    document.querySelector('#testRunButton1').textContent = 'run internal test';
                }
                break;
            // custom-case
            default:
                break;
            }
            Iif (document.querySelector('#inputTextareaEval1') && (!event || (event &&
                    event.currentTarget &&
                    event.currentTarget.className &&
                    event.currentTarget.className.includes &&
                    event.currentTarget.className.includes('oneval')))) {
                // try to eval input-code
                try {
                    /*jslint evil: true*/
                    eval(document.querySelector('#inputTextareaEval1').value);
                } catch (errorCaught) {
                    console.error(errorCaught);
                }
            }
        };
        // log stderr and stdout to #outputTextareaStdout1
        ['error', 'log'].forEach(function (key) {
            console[key + '_original'] = console[key];
            console[key] = function () {
                var element;
                console[key + '_original'].apply(console, arguments);
                element = document.querySelector('#outputTextareaStdout1');
                Iif (!element) {
                    return;
                }
                // append text to #outputTextareaStdout1
                element.value += Array.from(arguments).map(function (arg) {
                    return typeof arg === 'string'
                        ? arg
                        : JSON.stringify(arg, null, 4);
                }).join(' ') + '\n';
                // scroll textarea to bottom
                element.scrollTop = element.scrollHeight;
            };
        });
        // init event-handling
        ['change', 'click', 'keyup'].forEach(function (event) {
            Array.from(document.querySelectorAll('.on' + event)).forEach(function (element) {
                element.addEventListener(event, local.testRunBrowser);
            });
        });
        // run tests
        local.testRunBrowser();
        break;
 
 
 
    // run node js-env code - post-init
    /* istanbul ignore next */
    case 'node':
        // export local
        module.exports = local;
        // require modules
        local.fs = require('fs');
        local.http = require('http');
        local.url = require('url');
        // init assets
        local.assetsDict = local.assetsDict || {};
        /* jslint-ignore-begin */
        local.assetsDict['/assets.index.template.html'] = '\
<!doctype html>\n\
<html lang="en">\n\
<head>\n\
<meta charset="UTF-8">\n\
<meta name="viewport" content="width=device-width, initial-scale=1">\n\
<title>{{env.npm_package_name}} (v{{env.npm_package_version}})</title>\n\
<style>\n\
/*csslint\n\
    box-sizing: false,\n\
    universal-selector: false\n\
*/\n\
* {\n\
    box-sizing: border-box;\n\
}\n\
body {\n\
    background: #dde;\n\
    font-family: Arial, Helvetica, sans-serif;\n\
    margin: 2rem;\n\
}\n\
body > * {\n\
    margin-bottom: 1rem;\n\
}\n\
.utility2FooterDiv {\n\
    margin-top: 20px;\n\
    text-align: center;\n\
}\n\
</style>\n\
<style>\n\
/*csslint\n\
*/\n\
textarea {\n\
    font-family: monospace;\n\
    height: 10rem;\n\
    width: 100%;\n\
}\n\
textarea[readonly] {\n\
    background: #ddd;\n\
}\n\
</style>\n\
</head>\n\
<body>\n\
<!-- utility2-comment\n\
<div id="ajaxProgressDiv1" style="background: #d00; height: 2px; left: 0; margin: 0; padding: 0; position: fixed; top: 0; transition: background 0.5s, width 1.5s; width: 25%;"></div>\n\
utility2-comment -->\n\
<h1>\n\
<!-- utility2-comment\n\
    <a\n\
        {{#if env.npm_package_homepage}}\n\
        href="{{env.npm_package_homepage}}"\n\
        {{/if env.npm_package_homepage}}\n\
        target="_blank"\n\
    >\n\
utility2-comment -->\n\
        {{env.npm_package_name}} (v{{env.npm_package_version}})\n\
<!-- utility2-comment\n\
    </a>\n\
utility2-comment -->\n\
</h1>\n\
<h3>{{env.npm_package_description}}</h3>\n\
<!-- utility2-comment\n\
<h4><a download href="assets.app.js">download standalone app</a></h4>\n\
<button class="onclick onreset" id="testRunButton1">run internal test</button><br>\n\
<div id="testReportDiv1" style="display: none;"></div>\n\
utility2-comment -->\n\
\n\
\n\
\n\
<label>stderr and stdout</label>\n\
<textarea class="resettable" id="outputTextareaStdout1" readonly></textarea>\n\
<!-- utility2-comment\n\
{{#if isRollup}}\n\
<script src="assets.app.js"></script>\n\
{{#unless isRollup}}\n\
utility2-comment -->\n\
<script src="assets.utility2.rollup.js"></script>\n\
<script src="jsonp.utility2._stateInit?callback=window.utility2._stateInit"></script>\n\
<script src="assets.npmtest_rdb.rollup.js"></script>\n\
<script src="assets.example.js"></script>\n\
<script src="assets.test.js"></script>\n\
<!-- utility2-comment\n\
{{/if isRollup}}\n\
utility2-comment -->\n\
<div class="utility2FooterDiv">\n\
    [ this app was created with\n\
    <a href="https://github.com/kaizhu256/node-utility2" target="_blank">utility2</a>\n\
    ]\n\
</div>\n\
</body>\n\
</html>\n\
';
        /* jslint-ignore-end */
        Iif (local.templateRender) {
            local.assetsDict['/'] = local.templateRender(
                local.assetsDict['/assets.index.template.html'],
                {
                    env: local.objectSetDefault(local.env, {
                        npm_package_description: 'the greatest app in the world!',
                        npm_package_name: 'my-app',
                        npm_package_nameAlias: 'my_app',
                        npm_package_version: '0.0.1'
                    })
                }
            );
        } else {
            local.assetsDict['/'] = local.assetsDict['/assets.index.template.html']
                .replace((/\{\{env\.(\w+?)\}\}/g), function (match0, match1) {
                    // jslint-hack
                    String(match0);
                    switch (match1) {
                    case 'npm_package_description':
                        return 'the greatest app in the world!';
                    case 'npm_package_name':
                        return 'my-app';
                    case 'npm_package_nameAlias':
                        return 'my_app';
                    case 'npm_package_version':
                        return '0.0.1';
                    }
                });
        }
        // run the cli
        Eif (local.global.utility2_rollup || module !== require.main) {
            break;
        }
        local.assetsDict['/assets.example.js'] =
            local.assetsDict['/assets.example.js'] ||
            local.fs.readFileSync(__filename, 'utf8');
        // bug-workaround - long $npm_package_buildCustomOrg
        /* jslint-ignore-begin */
        local.assetsDict['/assets.npmtest_rdb.rollup.js'] =
            local.assetsDict['/assets.npmtest_rdb.rollup.js'] ||
            local.fs.readFileSync(
                local.npmtest_rdb.__dirname + '/lib.npmtest_rdb.js',
                'utf8'
            ).replace((/^#!/), '//');
        /* jslint-ignore-end */
        local.assetsDict['/favicon.ico'] = local.assetsDict['/favicon.ico'] || '';
        // if $npm_config_timeout_exit exists,
        // then exit this process after $npm_config_timeout_exit ms
        if (Number(process.env.npm_config_timeout_exit)) {
            setTimeout(process.exit, Number(process.env.npm_config_timeout_exit));
        }
        // start server
        if (local.global.utility2_serverHttp1) {
            break;
        }
        process.env.PORT = process.env.PORT || '8081';
        console.error('server starting on port ' + process.env.PORT);
        local.http.createServer(function (request, response) {
            request.urlParsed = local.url.parse(request.url);
            if (local.assetsDict[request.urlParsed.pathname] !== undefined) {
                response.end(local.assetsDict[request.urlParsed.pathname]);
                return;
            }
            response.statusCode = 404;
            response.end();
        }).listen(process.env.PORT);
        break;
    }
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
 
2
 
2
 
2
1
 
1
1
1
 
 
 
 
 
/* istanbul instrument in package npmtest_rdb */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - pre-init
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        // init utility2_rollup
        local = local.global.utility2_rollup || local;
        // init lib
        local.local = local.npmtest_rdb = local;
        // init exports
        if (local.modeJs === 'browser') {
            local.global.utility2_npmtest_rdb = local;
        } else {
            module.exports = local;
            module.exports.__dirname = __dirname;
            module.exports.module = module;
        }
    }());
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
 
 
 
 
 
 
 
 
 
 
2
 
2
 
 
 
 
2
 
2
 
2
2
2
 
 
 
 
1
 
 
 
 
 
 
2
 
 
2
 
 
1
 
 
 
1
 
 
1
 
1
 
 
2
 
 
 
 
 
2
2
 
2
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
2
2
 
2
 
 
 
 
 
1
 
 
 
 
 
 
1
 
 
 
1
 
 
1
 
 
 
 
 
 
1
 
 
 
 
 
 
1
1
 
 
1
 
 
 
 
 
 
1
1
1
1
1
1
 
 
1
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
2
2
 
 
1
 
 
 
 
 
 
1
1
 
 
 
1
1
 
 
 
 
/* istanbul instrument in package npmtest_rdb */
/*jslint
    bitwise: true,
    browser: true,
    maxerr: 8,
    maxlen: 96,
    node: true,
    nomen: true,
    regexp: true,
    stupid: true
*/
(function () {
    'use strict';
    var local;
 
 
 
    // run shared js-env code - pre-init
    (function () {
        // init local
        local = {};
        // init modeJs
        local.modeJs = (function () {
            try {
                return typeof navigator.userAgent === 'string' &&
                    typeof document.querySelector('body') === 'object' &&
                    typeof XMLHttpRequest.prototype.open === 'function' &&
                    'browser';
            } catch (errorCaughtBrowser) {
                return module.exports &&
                    typeof process.versions.node === 'string' &&
                    typeof require('http').createServer === 'function' &&
                    'node';
            }
        }());
        // init global
        local.global = local.modeJs === 'browser'
            ? window
            : global;
        switch (local.modeJs) {
        // re-init local from window.local
        case 'browser':
            local = local.global.utility2.objectSetDefault(
                local.global.utility2_rollup || local.global.local,
                local.global.utility2
            );
            break;
        // re-init local from example.js
        case 'node':
            local = (local.global.utility2_rollup || require('utility2'))
                .requireReadme();
            break;
        }
        // export local
        local.global.local = local;
    }());
 
 
 
    // run shared js-env code - function
    (function () {
        return;
    }());
    switch (local.modeJs) {
 
 
 
    // run browser js-env code - function
    case 'browser':
        break;
 
 
 
    // run node js-env code - function
    case 'node':
        break;
    }
 
 
 
    // run shared js-env code - post-init
    (function () {
        return;
    }());
    switch (local.modeJs) {
 
 
 
    // run browser js-env code - post-init
    case 'browser':
        local.testCase_browser_nullCase = local.testCase_browser_nullCase || function (
            options,
            onError
        ) {
        /*
         * this function will test browsers's null-case handling-behavior-behavior
         */
            onError(null, options);
        };
 
        // run tests
        local.nop(local.modeTest &&
            document.querySelector('#testRunButton1') &&
            document.querySelector('#testRunButton1').click());
        break;
 
 
 
    // run node js-env code - post-init
    /* istanbul ignore next */
    case 'node':
        local.testCase_buildApidoc_default = local.testCase_buildApidoc_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildApidoc's default handling-behavior-behavior
         */
            options = { modulePathList: module.paths };
            local.buildApidoc(options, onError);
        };
 
        local.testCase_buildApp_default = local.testCase_buildApp_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildApp's default handling-behavior-behavior
         */
            local.testCase_buildReadme_default(options, local.onErrorThrow);
            local.testCase_buildLib_default(options, local.onErrorThrow);
            local.testCase_buildTest_default(options, local.onErrorThrow);
            local.testCase_buildCustomOrg_default(options, local.onErrorThrow);
            options = [];
            local.buildApp(options, onError);
        };
 
        local.testCase_buildCustomOrg_default = local.testCase_buildCustomOrg_default ||
            function (options, onError) {
            /*
             * this function will test buildCustomOrg's default handling-behavior
             */
                options = {};
                local.buildCustomOrg(options, onError);
            };
 
        local.testCase_buildLib_default = local.testCase_buildLib_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildLib's default handling-behavior
         */
            options = {};
            local.buildLib(options, onError);
        };
 
        local.testCase_buildReadme_default = local.testCase_buildReadme_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildReadme's default handling-behavior-behavior
         */
            options = {};
            local.buildReadme(options, onError);
        };
 
        local.testCase_buildTest_default = local.testCase_buildTest_default || function (
            options,
            onError
        ) {
        /*
         * this function will test buildTest's default handling-behavior
         */
            options = {};
            local.buildTest(options, onError);
        };
 
        local.testCase_webpage_default = local.testCase_webpage_default || function (
            options,
            onError
        ) {
        /*
         * this function will test webpage's default handling-behavior
         */
            options = { modeCoverageMerge: true, url: local.serverLocalHost + '?modeTest=1' };
            local.browserTest(options, onError);
        };
 
        // run test-server
        local.testRunServer(local);
        break;
    }
}());
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1
1
 
1
 
 
 
 
 
 
 
 
 
1
 
var Domain = require('domain');
var negotiateForwardProperty = require('./createDomain/negotiateForwardProperty');
 
function createDomain() {
	var oldDomain = Domain.active || {};
	var domain = Domain.create();
	var ownProperties = Object.getOwnPropertyNames(oldDomain);
	ownProperties.forEach(function(propName) {
		negotiateForwardProperty(oldDomain, domain, propName);
	});
	return domain;
}
 
module.exports = createDomain;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
function emitEvent() {
	var callbacks = [];
	var emit = function() {
		
		var copy = callbacks.slice(0, callbacks.length);
		for (var i = 0; i < copy.length; i++) {
			var callback = copy[i];
			callback.apply(null,arguments);
		}
	};
 
	emit.add = function(callback) {
		callbacks.push(callback);
	};
 
	emit.tryAdd = function(callback) {
		if (callback)
			emit.add(callback);
	};	
 
	emit.remove = function(callback) {
		for (var i = 0; i < callbacks.length; i++) {			
			if(callbacks[i] == callback){
				callbacks.splice(i,1);
				return;
			}
		}
	};
 
	emit.tryRemove = function(callback) {
		if(callback)
			emit.remove(callback);
	};
 
	emit.clear = function() {
		callbacks = [];
	};
 
	return emit;
}
 
module.exports = emitEvent;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
1
1
1
 
 
 
1
1
 
1
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
1
 
 
 
1
 
 
var negotiateRawSqlFilter = require('./table/column/negotiateRawSqlFilter');
var parameterized = require('./table/query/newParameterized')('');
function emptyFilter() {
    return emptyFilter.and.apply(null, arguments);
}
 
emptyFilter.sql = parameterized.sql;
emptyFilter.parameters = parameterized.parameters;
 
emptyFilter.and = function(other) {
    other = negotiateRawSqlFilter(other);
    for (var i = 1; i < arguments.length; i++) {
        other = other.and(arguments[i]);
    }
    return other;
};
 
emptyFilter.or = function(other) {
    other = negotiateRawSqlFilter(other);
    for (var i = 1; i < arguments.length; i++) {
        other = other.or(arguments[i]);
    }
    return other;
};
 
emptyFilter.not = function() {
    return emptyFilter;
};
 
module.exports = emptyFilter;
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
4
 
4
 
 
 
 
 
4
4
4
 
 
 
 
 
 
 
 
 
 
 
var newPg = require('./pg/newDatabase');
 
var connectViaPool = function(connectionString, poolOptions) {
	if (connectionString.indexOf && connectionString.indexOf('mysql') === 0)
		return connectViaPool.mySql.apply(null, arguments);
	return newPg.apply(null, arguments);
};
 
connectViaPool.pg = newPg;
connectViaPool.mySql = require('./mySql/newDatabase');
connectViaPool.sqlite = require('./sqlite/newDatabase');
connectViaPool.table = require('./table');
connectViaPool.filter = require('./emptyFilter');
connectViaPool.commit = require('./table/commit');
connectViaPool.rollback = require('./table/rollback');
connectViaPool.end = require('./pools').end;
connectViaPool.log = require('./table/log').registerLogger;
connectViaPool.query = require('./query');
connectViaPool.lock = require('./lock');
module.exports = connectViaPool;
 
 

1
2
3
4
5
6
7
8
9
10
11
12
1
1
 
1
 
 
 
 
 
1
 
 
var query = require('./query');
var toIntKey = require('./lock/toIntKey');
 
function lock(key) {
    key = toIntKey(key);
    var sql = 'SELECT pg_advisory_xact_lock(' + key + ')';
    return query(sql);
}
 
module.exports = lock;
 
 

1
2
3
4
1
 
 
 
module.exports = function() {
	return [];
};
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
function newCollection() {
    var c = {};
    var initialArgs = [];
    for (var i = 0; i < arguments.length; i++) {
        initialArgs.push(arguments[i]);
    }
    var ranges = [initialArgs];
 
    c.addRange = function(otherCollection) {
        ranges.push(otherCollection);
    };
 
    c.add = function(element) {
        c.addRange([element]);
    };
 
    c.toArray = function(element) {
        var result = [];
        c.forEach(onEach);
        return result;
 
        function onEach(element) {
            result.push(element);
        }
    };
 
    c.forEach = function(callback) {
        var index = 0;
        for (var i = 0; i < ranges.length; i++) {
            ranges[i].forEach(onEach);
        }
 
        function onEach(element) {
            callback(element, index);
            index++;
        }
 
    };
 
    Object.defineProperty(c, 'length', {
        enumerable: false,
        get: function() {
        	var result = 0;
        	for (var i = 0; i < ranges.length; i++) {
        		result += ranges[i].length;
        	}
            return result;
        },
    });
 
 
    return c;
}
 
module.exports = newCollection;
 
 

1
2
1
 
module.exports = require('uuid').v4;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
1
 
 
 
 
1
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
1
 
function newImmutable(fn) {
	var result;
	var _run = runFirst;
	return run;
 
	function run() {	
		var args = [].slice.call(arguments);	
		return _run(args);
	}
 
	function runFirst(args) {
		result =  fn.apply(null, args);
		_run = runNIgnoreArgs;
		return result;
	}
 
	function runNIgnoreArgs() {
		return result;
	}
}
 
module.exports = newImmutable;
 

1
2
3
4
5
6
1
2
 
 
1
 
function newObject() {
	return {};
}
 
module.exports = newObject;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1
1
 
1
 
 
 
 
1
 
 
 
 
 
 
 
 
1
 
 
var promise = require('./table/promise');
var pools = require('./newObject')();
 
Object.defineProperty(pools, 'end', {
    enumerable: false,
    value: end
});
 
function end() {
    var all = [];
    for (var poolId in pools) {
    	var endPool = pools[poolId].end();
    	all.push(endPool);
    }
    return promise.all(all);
}
 
module.exports = pools;
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
1
 
1
 
 
 
 
1
 
 
 
1
 
var executeQueries = require('./table/executeQueries');
var wrapQuery = require('./query/wrapQuery');
 
function doQuery(query) {
	var wrappedQuery = wrapQuery(query);
	return executeQueries([wrappedQuery]).then(unwrapResult);
}
 
function unwrapResult(results) {
	return results[0];
}
 
module.exports = doQuery;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
1
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
 
var newColumn = require('./table/column/newColumn');
var column = require('./table/column');
var join = require('./table/join');
var hasMany = require('./table/hasMany');
var hasOne = require('./table/hasOne');
var getMany = require('./table/getMany');
var getById = require('./table/getById');
var tryGetById = require('./table/tryGetById');
var tryGetFirst = require('./table/tryGetFirstFromDb');
var newCache = require('./table/newRowCache');
var newContext = require('./newObject');
var insert = require('./table/insert');
var _delete = require('./table/delete');
var cascadeDelete = require('./table/cascadeDelete');
var createReadStream = require('./table/createReadStream');
var createJSONReadStream = require('./table/createJSONReadStream');
 
function _new(tableName) {
    var table = newContext();
    table._dbName = tableName;
    table._primaryColumns = [];
    table._columns = [];
    table._columnDiscriminators = [];
    table._formulaDiscriminators = [];
    table._relations = {};
    table._cache = newCache(table);
 
    table.primaryColumn = function(columnName) {
        var columnDef = newColumn(table, columnName);
        table._primaryColumns.push(columnDef);
        return column(columnDef, table);
    };
 
    table.column = function(columnName) {
        var columnDef = newColumn(table, columnName);
        return column(columnDef, table);
    };
 
    table.join = function(relatedTable) {
        return join(table, relatedTable);
    };
 
    table.hasMany = function(joinRelation) {
        return hasMany(joinRelation);
    };
 
    table.hasOne = function(joinRelation) {
        return hasOne(joinRelation);
    };
 
    table.getMany = function(filter, strategy) {
        return getMany(table, filter, strategy);
    };
 
    table.getMany.exclusive = function(filter, strategy) {
        return getMany.exclusive(table, filter, strategy);
    };
 
    table.tryGetFirst = function() {
        return call(tryGetFirst, arguments);
    };
    table.tryGetFirst.exclusive = function() {
        return call(tryGetFirst.exclusive, arguments);
    };
 
    function call(func, args) {
        var mergedArgs = [table];
        for (var i = 0; i < args.length; i++) {
            mergedArgs.push(args[i]);
        }
        return func.apply(null, mergedArgs);
    }
 
    table.getById = function() {
        return call(getById, arguments);
    };
    table.getById.exclusive = function() {
        return call(getById.exclusive, arguments);
    };
 
 
    table.tryGetById = function() {
        return call(tryGetById, arguments);
    };
 
    table.tryGetById.exclusive = function() {
        return call(tryGetById.exclusive, arguments);
    };
 
    table.columnDiscriminators = function() {
        for (var i = 0; i < arguments.length; i++) {
            table._columnDiscriminators.push(arguments[i]);
        }
        return table;
    };
 
    table.formulaDiscriminators = function() {
        for (var i = 0; i < arguments.length; i++) {
            table._formulaDiscriminators.push(arguments[i]);
        }
        return table;
    };
 
    table.insert = function() {
        return call(insert, arguments);
    };
 
    table.delete = _delete.bind(null, table);
    table.cascadeDelete = cascadeDelete.bind(null, table);
 
    table.createReadStream = createReadStream.bind(null, table);
    table.createJSONReadStream = createJSONReadStream.bind(null, table);
    table.exclusive = function() {
        table._exclusive = true;
        return table;
    };
    return table;
}
 
module.exports = _new;
 
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1
 
 
 
 
 
 
 
 
 
1
 
 
 
 
 
1
 
 
 
 
 
1
 
function negotiateForwardProperty(oldDomain, newDomain, propertyName) {
	if(newDomain[propertyName]) return;
	if (propertyName === 'rdb') return;
	Object.defineProperty(newDomain, propertyName, {
		enumerable: true,
		get: createGetter(oldDomain, propertyName),
		set: createSetter(oldDomain, propertyName)
	});
}
 
function createGetter(oldDomain, propName) {
	return function() {
		return oldDomain[propName];
	};
}
 
function createSetter(oldDomain, propName) {
	return function(value) {
		oldDomain[propName] = value;
	};
}
 
module.exports = negotiateForwardProperty;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
var a = require('a');
 
function act(c){
	c.mock = a.mock;
	c.requireMock = a.requireMock;
	c.expectRequire = a.expectRequire;
	c.then = a.then;
	
	c.newDomain = {};
	c.oldDomain = {};
 
	c.oldFoo = {};
	c.existingFoo = {};
	c.oldDomain.foo = c.oldFoo;
	c.newDomain.foo = c.existingFoo;
	c.propertyName = 'foo';
 
	require('../negotiateForwardProperty')(c.oldDomain, c.newDomain, c.propertyName);
}
 
module.exports = act;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
2
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
var a = require('a');
 
function act(c){
	c.mock = a.mock;
	c.requireMock = a.requireMock;
	c.expectRequire = a.expectRequire;
	c.then = a.then;
	
	c.newDomain = {};
	c.oldDomain = {};
 
	c.oldFoo = {};
	c.newFoo = {};
	c.oldDomain.foo = c.oldFoo;
	c.propertyName = 'foo';
 
	require('../negotiateForwardProperty')(c.oldDomain, c.newDomain, c.propertyName);
	c.originalValue = c.newDomain.foo;
	c.newDomain.foo = c.newFoo;
}
 
module.exports = act;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
var a = require('a');
 
function act(c){
	c.mock = a.mock;
	c.requireMock = a.requireMock;
	c.expectRequire = a.expectRequire;
	c.then = a.then;
	
	c.newDomain = {};
	c.oldDomain = {};
 
	c.oldRdb = {};
	c.oldDomain.rdb = c.oldRdb;
	c.propertyName = 'rdb';
 
	require('../negotiateForwardProperty')(c.oldDomain, c.newDomain, c.propertyName);
 
}
 
module.exports = act;
 

1
2
3
4
5
6
2
 
 
 
 
 
var when = require('a').when;
var c = {};
 
when(c)
    .it('should not forward existing').assertEqual(c.newDomain.foo, c.existingFoo)
 

1
2
3
4
5
6
7
8
2
 
 
 
 
 
 
 
var when = require('a').when;
var c = {};
 
when(c)
    .it('should forward property getter through new domain').assertEqual(c.oldFoo, c.originalValue)
    .it('should update value on old domain when setting on new domain').assertEqual(c.newFoo, c.oldDomain.foo)
 
 

1
2
3
4
5
6
2
 
 
 
 
 
var when = require('a').when;
var c = {};
 
when(c)
    .it('should not forward rdb').assertNotEqual(c.oldDomain.rdb, c.newDomain.rdb)
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
var a = require('a');
 
function act(c){
	c.mock = a.mock;
	c.requireMock = a.requireMock;
	c.expectRequire = a.expectRequire;
	c.then = a.then;
	
	c.Domain = c.requireMock('domain');
	c.negotiateForwardProperty = c.requireMock('./createDomain/negotiateForwardProperty');
 
	c.sut = require('../createDomain');
}
 
module.exports = act;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
var a = require('a');
 
function act(c) {
	c.domain = {};
	c.Domain.active = c.domain;
 
	c.newDomain = {};
	c.Domain.create = c.mock();
	c.Domain.create.expect().return(c.newDomain);
 
	c.newBar = {};
	c.baz = {};
 
	c.domain.foo = {};
	c.domain.bar = {};
	c.domain.baz = {};
 
	c.negotiateForwardProperty.expect(c.domain, c.newDomain, 'foo');
	c.negotiateForwardProperty.expect(c.domain, c.newDomain, 'bar');
	c.negotiateForwardProperty.expect(c.domain, c.newDomain, 'baz');
	
	c.returned = c.sut();
}
 
module.exports = act;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
2
 
1
 
 
 
 
 
 
 
 
 
 
var a = require('a');
 
function act(c) {
	c.Domain.create = c.mock();
 
	c.newDomain = {};
	c.Domain.create.expect().return(c.newDomain);
 
	c.returned = c.sut();
}
 
module.exports = act;
 

1
2
3
4
5
6
7
8
2
 
 
 
 
 
 
 
var when = require('a').when;
var c = {};
 
when(c)
.it('should forward properties of old domain').assertDoesNotThrow(c.negotiateForwardProperty.verify)
.it('should return new domain').assertEqual(c.newDomain, c.returned)
 
 

1
2
3
4
5
6
2
 
 
 
 
 
var when = require('a').when;
var c = {};
 
when(c)
.it('should return a new domain').assertEqual(c.newDomain, c.returned)
 

1
2
3
4
5
6
7
1
 
 
 
 
1
 
function act(c) {
	c.mock = require('a').mock;
	c.sut = require('../emitEvent')();
}
 
module.exports = act;
 

1
2
3
4
5
6
7
8
9
10
11
 
1
 
 
 
 
 
 
1
1
 
 
function act(c) {
	c.callback = c.mock();
	c.callback2 = c.mock();
	c.sut.add(c.callback);
	c.sut.add(c.callback2);
}
 
act.base = '../new';
module.exports = act;
 

1
2
3
4
5
6
7
1
 
 
 
1
1
 
function act(c) {
	c.sut();
}
 
act.base = '../new';
module.exports = act;
 

1
2
3
4
5
6
7
8
9
10
11
1
 
1
 
 
 
 
 
1
1
 
var callback = 'foo';
 
function act(c) {	
	c.sut.add = c.mock();
	c.sut.add.expect(callback);
	c.sut.tryAdd(callback);
}
 
act.base = '../new';
module.exports = act;
 

1
2
3
4
5
6
7
8
9
 
1
 
 
 
 
1
1
 
 
function act(c) {	
	c.sut.add = c.mock();
	c.sut.tryAdd();
}
 
act.base = '../new';
module.exports = act;
 

1
2
3
4
5
6
7
8
9
10
11
1
 
1
 
 
 
 
 
1
1
 
var callback = 'foo';
 
function act(c) {	
	c.sut.remove = c.mock();
	c.sut.remove.expect(callback);
	c.sut.tryRemove(callback);
}
 
act.base = '../new';
module.exports = act;
 

1
2
3
4
5
6
7
8
9
 
1
 
 
 
 
1
1
 
 
function act(c) {	
	c.sut.remove = c.mock();
	c.sut.tryRemove();
}
 
act.base = '../new';
module.exports = act;
 

1
2
3
4
5
6
2
 
 
 
 
 
var when = require('a').when;
var c = {};
 
when(c)
	.it('should not crash').assertOk('ok');
 

1
2
3
4
5
6
2
 
 
 
 
 
var when = require('a').when;
var c = {};
 
when(c)
	.it('forward to add').assertDoesNotThrow(c.sut.add.verify);
 

1
2
3
4
5
6
2
 
 
 
 
 
var when = require('a').when;
var c = {};
 
when(c)
	.it('not forward to add').assertDoesNotThrow(c.sut.add.verify);
 

1
2
3
4
5
6
2
 
 
 
 
 
var when = require('a').when;
var c = {};
 
when(c)
	.it('forward to remove').assertDoesNotThrow(c.sut.remove.verify);
 

1
2
3
4
5
6
2
 
 
 
 
 
var when = require('a').when;
var c = {};
 
when(c)
	.it('should not forward to remove').assertDoesNotThrow(c.sut.remove.verify);
 

1
2
3
4
5
6
7
1
 
 
 
1
1
 
function act(c) {
	c.sut.clear();
}
 
act.base = '../add';
module.exports = act;
 

1
2
3
4
5
6
7
1
 
 
 
1
1
 
function act(c) {
	c.sut.remove(c.callback);
}
 
act.base = '../add';
module.exports = act;
 

1
2
3
4
5
6
7
2
 
 
 
 
 
 
var when = require('a').when;
var c = {};
 
when(c)
	.it('should invoke callback').assertDoesNotThrow(c.callback.verify)
	.it('should invoke callback2').assertDoesNotThrow(c.callback2.verify);
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
 
 
 
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
var a = require('a');
var requireMock = a.requireMock;
var mock = a.mock;
 
function act(c) {	
	c.mock = mock;
	c.negotiateRawSqlFilter = requireMock('./table/column/negotiateRawSqlFilter');
	
	c.newParameterized =  requireMock('./table/query/newParameterized');
	c.parameterized = {};
	c.newParameterized.expect('').return(c.parameterized);
	c.sql = {};
	c.parameterized.sql = c.sql;
	c.parameters = {};
	c.parameterized.parameters = c.parameters;
	c.input = {};
 
	c.sut = require('../emptyFilter');
}
 
module.exports = act;
 

1
2
3
4
5
6
7
8
2
 
 
 
 
 
 
 
var when = require('a').when;
var c = {};
 
when(c)
	.it('parameters points at parameterized.parameters').assertEqual( c.parameters, c.sut.parameters)
	.it('sql points at parameterized.sql').assertEqual( c.sql, c.sut.sql)
	.it('not returns self').assertEqual( c.sut, c.sut.not())
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
function act(c){
	c.filter = {};
	c.filter2 = {};
	c.initialFilter = {};
	c.initialFilter2 = {};
	c.expected = {};
 
	c.negotiateRawSqlFilter.expect(c.initialFilter).return(c.filter);
 
	c.filter.and = c.mock();
	c.filter.and.expect(c.initialFilter2).return(c.expected);
 
	c.returned = c.sut.and(c.initialFilter, c.initialFilter2);
}
 
module.exports = act;
 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
 
function act(c){
	c.filter = {};
	c.filter2 = {};
	c.initialFilter = {};
	c.initialFilter2 = {};
	c.expected = {};
 
	c.negotiateRawSqlFilter.expect(c.initialFilter).return(c.filter);
 
	c.filter.or = c.mock();
	c.filter.or.expect(c.initialFilter2).return(c.expected);
 
	c.returned = c.sut.or(c.initialFilter, c.initialFilter2);
}
 
module.exports = act;
 

1
2
3
4
5
6
7
2
 
 
 
 
 
 
var when = require('a').when;
var c = {};
 
when(c)
	.it('should return negotiatedFilter').assertEqual(c.expected, c.returned)
	
 

1
2
3
4
5
6
7
2
 
 
 
 
 
 
var when = require('a').when;
var c = {};
 
when(c)
	.it('should return negotiatedFilter').assertEqual(c.expected, c.returned)